home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Games / Doom / ADoom-0.8 / ADoom_src / w_wad.c < prev    next >
C/C++ Source or Header  |  1998-06-24  |  11KB  |  597 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Handles WAD file header, directory, lump I/O.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: w_wad.c,v 1.5 1997/02/03 16:47:57 b1 Exp $";
  27.  
  28.  
  29. #ifdef NORMALUNIX
  30. #ifndef __SASC
  31. #include <ctype.h>
  32. #include <sys/types.h>
  33. #include <string.h>
  34. #include <unistd.h>
  35. #include <malloc.h>
  36. #include <fcntl.h>
  37. #include <sys/stat.h>
  38. #include <alloca.h>
  39. #define O_BINARY        0
  40. #else
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <ctype.h>
  45. #include <stat.h>
  46. #endif
  47. #endif
  48.  
  49. #include "doomdef.h"
  50. #include "doomtype.h"
  51. #include "m_swap.h"
  52. #include "i_system.h"
  53. #include "z_zone.h"
  54.  
  55. #ifdef __GNUG__
  56. #pragma implementation "w_wad.h"
  57. #endif
  58. #include "w_wad.h"
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65. //
  66. // GLOBALS
  67. //
  68.  
  69. // Location of each lump on disk.
  70. lumpinfo_t*        lumpinfo;        
  71. int            numlumps;
  72.  
  73. void**            lumpcache;
  74.  
  75.  
  76. #ifndef __SASC
  77. #define strcmpi    strcasecmp
  78.  
  79. void strupr (char* s)
  80. {
  81.     while (*s) { *s = toupper(*s); s++; }
  82. }
  83. #endif
  84.  
  85. int filelength (int handle) 
  86. { 
  87.     struct stat    *fileinfo;
  88.     int size;
  89.     
  90.     if ((fileinfo = malloc (sizeof(struct stat))) == NULL ||
  91.         fstat (handle,fileinfo) == -1)
  92.     I_Error ("Error fstating");
  93.     size = fileinfo->st_size;
  94.     free (fileinfo);
  95.  
  96.     return size;
  97. }
  98.  
  99.  
  100. void
  101. ExtractFileBase
  102. ( char*        path,
  103.   char*        dest )
  104. {
  105.     char*    src;
  106.     int        length;
  107.  
  108.     src = path + strlen(path) - 1;
  109.     
  110.     // back up until a \ or the start
  111.     while (src != path
  112.        && *(src-1) != '\\'
  113.        && *(src-1) != '/')
  114.     {
  115.     src--;
  116.     }
  117.     
  118.     // copy up to eight characters
  119.     memset (dest,0,8);
  120.     length = 0;
  121.     
  122.     while (*src && *src != '.')
  123.     {
  124.     if (++length == 9)
  125.         I_Error ("Filename base of %s >8 chars",path);
  126.  
  127.     *dest++ = toupper((int)*src++);
  128.     }
  129. }
  130.  
  131.  
  132.  
  133.  
  134.  
  135. //
  136. // LUMP BASED ROUTINES.
  137. //
  138.  
  139. //
  140. // W_AddFile
  141. // All files are optional, but at least one file must be
  142. //  found (PWAD, if all required lumps are present).
  143. // Files with a .wad extension are wadlink files
  144. //  with multiple lumps.
  145. // Other files are single lumps with the base filename
  146. //  for the lump name.
  147. //
  148. // If filename starts with a tilde, the file is handled
  149. //  specially to allow map reloads.
  150. // But: the reload feature is a fragile hack...
  151.  
  152. int            reloadlump;
  153. char*            reloadname;
  154.  
  155.  
  156. void W_AddFile (char *filename)
  157. {
  158.     wadinfo_t        header;
  159.     lumpinfo_t*        lump_p;
  160.     unsigned        i;
  161.     FILE        *handle;
  162.     int            length;
  163.     int            startlump;
  164.     filelump_t*        fileinfo = NULL;
  165.     filelump_t        singleinfo;
  166.     FILE        *storehandle;
  167.     
  168.     // open the file and add to directory
  169.  
  170.     // handle reload indicator.
  171.     if (filename[0] == '~')
  172.     {
  173.     filename++;
  174.     reloadname = filename;
  175.     reloadlump = numlumps;
  176.     }
  177.         
  178.     if ( (handle = fopen (filename,"r")) == NULL)
  179.     {
  180.     printf (" couldn't open %s\n",filename);
  181.     return;
  182.     }
  183.  
  184.     printf (" adding %s\n",filename);
  185.     startlump = numlumps;
  186.     
  187.     if (strcmpi (filename+strlen(filename)-3 , "wad" ) )
  188.     {
  189.     // single lump file
  190.     fileinfo = &singleinfo;
  191.     singleinfo.filepos = 0;
  192.     singleinfo.size = LONG(filelength(fileno(handle)));
  193.     ExtractFileBase (filename, singleinfo.name);
  194.     numlumps++;
  195.     }
  196.     else 
  197.     {
  198.     // WAD file
  199.     fread (&header, 1, sizeof(header), handle);
  200.     if (strncmp(header.identification,"IWAD",4))
  201.     {
  202.         // Homebrew levels?
  203.         if (strncmp(header.identification,"PWAD",4))
  204.         {
  205.         I_Error ("Wad file %s doesn't have IWAD "
  206.              "or PWAD id\n", filename);
  207.         }
  208.         
  209.         // ???modifiedgame = true;        
  210.     }
  211.     header.numlumps = LONG(header.numlumps);
  212.     header.infotableofs = LONG(header.infotableofs);
  213.     length = header.numlumps*sizeof(filelump_t);
  214.     fileinfo = malloc (length);
  215.     fseek (handle, header.infotableofs, SEEK_SET);
  216.     fread (fileinfo, 1, length, handle);
  217.     numlumps += header.numlumps;
  218.     }
  219.  
  220.     
  221.     // Fill in lumpinfo
  222.     lumpinfo = realloc (lumpinfo, numlumps*sizeof(lumpinfo_t));
  223.  
  224.     if (!lumpinfo)
  225.     I_Error ("Couldn't realloc lumpinfo");
  226.  
  227.     lump_p = &lumpinfo[startlump];
  228.     
  229.     storehandle = reloadname ? NULL : handle;
  230.     
  231.     for (i=startlump ; i<numlumps ; i++,lump_p++, fileinfo++)
  232.     {
  233.     lump_p->handle = storehandle;
  234.     lump_p->position = LONG(fileinfo->filepos);
  235.     lump_p->size = LONG(fileinfo->size);
  236.     strncpy (lump_p->name, fileinfo->name, 8);
  237.     }
  238.     
  239.     if (reloadname)
  240.     fclose (handle);
  241.     if (fileinfo != NULL)
  242.         free (fileinfo);
  243. }
  244.  
  245.  
  246.  
  247.  
  248. //
  249. // W_Reload
  250. // Flushes any of the reloadable lumps in memory
  251. //  and reloads the directory.
  252. //
  253. void W_Reload (void)
  254. {
  255.     wadinfo_t        header;
  256.     int            lumpcount;
  257.     lumpinfo_t*        lump_p;
  258.     unsigned        i;
  259.     FILE        *handle;
  260.     int            length;
  261.     filelump_t*        fileinfo = NULL;
  262.     
  263.     if (!reloadname)
  264.     return;
  265.         
  266.     if ( (handle = fopen (reloadname,"r")) == NULL)
  267.     I_Error ("W_Reload: couldn't open %s",reloadname);
  268.  
  269.     fread (&header, 1, sizeof(header), handle);
  270.     lumpcount = LONG(header.numlumps);
  271.     header.infotableofs = LONG(header.infotableofs);
  272.     length = lumpcount*sizeof(filelump_t);
  273.     fileinfo = malloc (length);
  274.     fseek (handle, header.infotableofs, SEEK_SET);
  275.     fread (fileinfo, 1, length, handle);
  276.     
  277.     // Fill in lumpinfo
  278.     lump_p = &lumpinfo[reloadlump];
  279.     
  280.     for (i=reloadlump ;
  281.      i<reloadlump+lumpcount ;
  282.      i++,lump_p++, fileinfo++)
  283.     {
  284.     if (lumpcache[i])
  285.         Z_Free (lumpcache[i]);
  286.  
  287.     lump_p->position = LONG(fileinfo->filepos);
  288.     lump_p->size = LONG(fileinfo->size);
  289.     }
  290.     
  291.     fclose (handle);
  292.     if (fileinfo != NULL)
  293.        free (fileinfo);
  294. }
  295.  
  296.  
  297.  
  298. //
  299. // W_InitMultipleFiles
  300. // Pass a null terminated list of files to use.
  301. // All files are optional, but at least one file
  302. //  must be found.
  303. // Files with a .wad extension are idlink files
  304. //  with multiple lumps.
  305. // Other files are single lumps with the base filename
  306. //  for the lump name.
  307. // Lump names can appear multiple times.
  308. // The name searcher looks backwards, so a later file
  309. //  does override all earlier ones.
  310. //
  311. void W_InitMultipleFiles (char** filenames)
  312. {    
  313.     int        size;
  314.     
  315.     // open all the files, load headers, and count lumps
  316.     numlumps = 0;
  317.  
  318.     // will be realloced as lumps are added
  319.     lumpinfo = malloc(1);    
  320.  
  321.     for ( ; *filenames ; filenames++)
  322.     W_AddFile (*filenames);
  323.  
  324.     if (!numlumps)
  325.     I_Error ("W_InitFiles: no files found");
  326.     
  327.     // set up caching
  328.     size = numlumps * sizeof(*lumpcache);
  329.     lumpcache = malloc (size);
  330.     
  331.     if (!lumpcache)
  332.     I_Error ("Couldn't allocate lumpcache");
  333.  
  334.     memset (lumpcache,0, size);
  335. }
  336.  
  337.  
  338.  
  339.  
  340. //
  341. // W_InitFile
  342. // Just initialize from a single file.
  343. //
  344. void W_InitFile (char* filename)
  345. {
  346.     char*    names[2];
  347.  
  348.     names[0] = filename;
  349.     names[1] = NULL;
  350.     W_InitMultipleFiles (names);
  351. }
  352.  
  353.  
  354.  
  355. //
  356. // W_NumLumps
  357. //
  358. int W_NumLumps (void)
  359. {
  360.     return numlumps;
  361. }
  362.  
  363.  
  364.  
  365. //
  366. // W_CheckNumForName
  367. // Returns -1 if name not found.
  368. //
  369.  
  370. int W_CheckNumForName (char* name)
  371. {
  372.     union {
  373.     char    s[9];
  374.     int    x[2];
  375.     
  376.     } name8;
  377.     
  378.     int        v1;
  379.     int        v2;
  380.     lumpinfo_t*    lump_p;
  381.  
  382.     // make the name into two integers for easy compares
  383.     strncpy (name8.s,name,8);
  384.  
  385.     // in case the name was a fill 8 chars
  386.     name8.s[8] = 0;
  387.  
  388.     // case insensitive
  389.     strupr (name8.s);        
  390.  
  391.     v1 = name8.x[0];
  392.     v2 = name8.x[1];
  393.  
  394.  
  395.     // scan backwards so patch lump files take precedence
  396.     lump_p = lumpinfo + numlumps;
  397.  
  398.     while (lump_p-- != lumpinfo)
  399.     {
  400.     if ( *(int *)lump_p->name == v1
  401.          && *(int *)&lump_p->name[4] == v2)
  402.     {
  403.         return lump_p - lumpinfo;
  404.     }
  405.     }
  406.  
  407.     // TFB. Not found.
  408.     return -1;
  409. }
  410.  
  411.  
  412.  
  413.  
  414. //
  415. // W_GetNumForName
  416. // Calls W_CheckNumForName, but bombs out if not found.
  417. //
  418. int W_GetNumForName (char* name)
  419. {
  420.     int    i;
  421.  
  422.     i = W_CheckNumForName (name);
  423.     
  424.     if (i == -1)
  425.       I_Error ("W_GetNumForName: %s not found!", name);
  426.       
  427.     return i;
  428. }
  429.  
  430.  
  431. //
  432. // W_LumpLength
  433. // Returns the buffer size needed to load the given lump.
  434. //
  435. int W_LumpLength (int lump)
  436. {
  437.     if (lump >= numlumps)
  438.     I_Error ("W_LumpLength: %i >= numlumps",lump);
  439.  
  440.     return lumpinfo[lump].size;
  441. }
  442.  
  443.  
  444.  
  445. //
  446. // W_ReadLump
  447. // Loads the lump into the given buffer,
  448. //  which must be >= W_LumpLength().
  449. //
  450. void
  451. W_ReadLump
  452. ( int        lump,
  453.   void*        dest )
  454. {
  455.     int        c;
  456.     lumpinfo_t*    l;
  457.     FILE    *handle;
  458.     
  459.     if (lump >= numlumps)
  460.     I_Error ("W_ReadLump: %i >= numlumps",lump);
  461.  
  462.     l = lumpinfo+lump;
  463.     
  464.     // ??? I_BeginRead ();
  465.     
  466.     if (l->handle == NULL)
  467.     {
  468.     // reloadable file, so use open / read / close
  469.     if ( (handle = fopen (reloadname,"r")) == NULL)
  470.         I_Error ("W_ReadLump: couldn't open %s",reloadname);
  471.     }
  472.     else
  473.     handle = l->handle;
  474.         
  475.     fseek (handle, l->position, SEEK_SET);
  476.     c = fread (dest, 1, l->size, handle);
  477.  
  478.     if (c < l->size)
  479.     I_Error ("W_ReadLump: only read %i of %i on lump %i",
  480.          c,l->size,lump);    
  481.  
  482.     if (l->handle == NULL)
  483.     fclose (handle);
  484.         
  485.     // ??? I_EndRead ();
  486. }
  487.  
  488.  
  489.  
  490.  
  491. //
  492. // W_CacheLumpNum
  493. //
  494. void*
  495. W_CacheLumpNum
  496. ( int        lump,
  497.   int        tag )
  498. {
  499.     byte*    ptr;
  500.  
  501.     if ((unsigned)lump >= numlumps)
  502.     I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
  503.         
  504.     if (!lumpcache[lump])
  505.     {
  506.     // read the lump in
  507.     
  508.     //printf ("cache miss on lump %i\n",lump);
  509.     ptr = Z_Malloc (W_LumpLength (lump), tag, &lumpcache[lump]);
  510.     W_ReadLump (lump, lumpcache[lump]);
  511.     }
  512.     else
  513.     {
  514.     //printf ("cache hit on lump %i\n",lump);
  515.     Z_ChangeTag (lumpcache[lump],tag);
  516.     }
  517.     
  518.     return lumpcache[lump];
  519. }
  520.  
  521.  
  522.  
  523. //
  524. // W_CacheLumpName
  525. //
  526. void*
  527. W_CacheLumpName
  528. ( char*        name,
  529.   int        tag )
  530. {
  531.     return W_CacheLumpNum (W_GetNumForName(name), tag);
  532. }
  533.  
  534.  
  535. //
  536. // W_Profile
  537. //
  538. FAR int        info[2500][10];
  539. int        profilecount;
  540.  
  541. void W_Profile (void)
  542. {
  543.     int        i;
  544.     memblock_t*    block;
  545.     void*    ptr;
  546.     char    ch;
  547.     FILE*    f;
  548.     int        j;
  549.     char    name[9];
  550.     
  551.     
  552.     for (i=0 ; i<numlumps ; i++)
  553.     {    
  554.     ptr = lumpcache[i];
  555.     if (!ptr)
  556.     {
  557.         ch = ' ';
  558.         continue;
  559.     }
  560.     else
  561.     {
  562.         block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
  563.         if (block->tag < PU_PURGELEVEL)
  564.         ch = 'S';
  565.         else
  566.         ch = 'P';
  567.     }
  568.     info[i][profilecount] = ch;
  569.     }
  570.     profilecount++;
  571.     
  572.     f = fopen ("waddump.txt","w");
  573.     name[8] = 0;
  574.  
  575.     for (i=0 ; i<numlumps ; i++)
  576.     {
  577.     memcpy (name,lumpinfo[i].name,8);
  578.  
  579.     for (j=0 ; j<8 ; j++)
  580.         if (!name[j])
  581.         break;
  582.  
  583.     for ( ; j<8 ; j++)
  584.         name[j] = ' ';
  585.  
  586.     fprintf (f,"%s ",name);
  587.  
  588.     for (j=0 ; j<profilecount ; j++)
  589.         fprintf (f,"    %c",info[i][j]);
  590.  
  591.     fprintf (f,"\n");
  592.     }
  593.     fclose (f);
  594. }
  595.  
  596.  
  597.